home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 November: Tool Chest / Dev.CD Nov 98 TC.toast / Sample Code / Text / SimpleText Sample / Clipboard.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-10-17  |  11.1 KB  |  396 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        Clipboard.c
  3.  
  4.     Contains:    Clipboard support for simple text application.
  5.  
  6.     Version:    SimpleText 1.4 or later
  7.  
  8. ** Copyright 1993-1996 Apple Computer. All rights reserved.
  9. **
  10. **    You may incorporate this sample code into your applications without
  11. **    restriction, though the sample code has been provided "AS IS" and the
  12. **    responsibility for its operation is 100% yours.  However, what you are
  13. **    not permitted to do is to redistribute the source as "DSC Sample Code"
  14. **    after having made changes. If you're going to re-distribute the source,
  15. **    we require that you make it clear in the source that the code was
  16. **    descended from Apple Sample Code, but that you've made changes.
  17.  
  18. */
  19.  
  20. #include "MacIncludes.h"
  21.  
  22. #include "Clipboard.h"
  23.  
  24.  
  25. // --------------------------------------------------------------------------------------------------------------
  26. // GLOBALS FOR THIS FILE ONLY
  27. // --------------------------------------------------------------------------------------------------------------
  28. static Handle            gScrapHandle;
  29. static long                gCurrentOffset;
  30. static QDProcsPtr          gSavedProcs;
  31. static QDProcs            gMyProcs;
  32. static CQDProcs            gMyColorProcs;
  33.  
  34. // --------------------------------------------------------------------------------------------------------------
  35. // INTERNAL ROUTINES
  36. // --------------------------------------------------------------------------------------------------------------
  37. static pascal void GetPICTData(Ptr dataPtr, short byteCount)
  38. /*
  39.     replacement for the QuickDraw bottleneck routine
  40. */
  41. { 
  42.     long    longCount = byteCount;
  43.     
  44.     BlockMoveData((*gScrapHandle)+gCurrentOffset, dataPtr, longCount);
  45.     gCurrentOffset += longCount;
  46.     
  47. } // GetPICTData
  48.  
  49. #if GENERATINGCFM
  50.     static RoutineDescriptor gGetPICTDataRD = BUILD_ROUTINE_DESCRIPTOR(uppQDGetPicProcInfo, GetPICTData);
  51.     static QDGetPicUPP gGetPICTData = &gGetPICTDataRD;
  52. #else
  53.     static QDGetPicUPP gGetPICTData = NewQDGetPicProc(GetPICTData);
  54. #endif
  55.  
  56. // --------------------------------------------------------------------------------------------------------------
  57.  
  58. static OSErr DrawPictureFromHandleAndOffset(
  59.     Rect    * pWhereToDraw,            // draw picture at this location
  60.     Handle    sourceHandle,            // handle containing data
  61.     long    sourceOffset)            // offset within handle to start at
  62. {
  63.     OSErr        anErr;
  64.     Rect        whereToDraw = *pWhereToDraw;
  65.     PicHandle    tempPict = (PicHandle) NewHandle(sizeof(Picture));
  66.     
  67.     anErr = MemError();
  68.     nrequire(anErr, FailedNewHandle);
  69.         
  70.     // calculate the rectangle in which to draw, save the picture header into
  71.     // our handle
  72.     {    
  73.     PicPtr    pPicture;
  74.     
  75.     pPicture = (PicPtr)((*sourceHandle) + sourceOffset);
  76.     whereToDraw.right = whereToDraw.left + pPicture->picFrame.right - pPicture->picFrame.left;
  77.     whereToDraw.bottom = whereToDraw.top + pPicture->picFrame.bottom - pPicture->picFrame.top;
  78.     BlockMoveData((Ptr)pPicture, (Ptr)*tempPict, sizeof(Picture));
  79.     }
  80.  
  81.     // store into globals for our GetPicProc in preparation for the draw
  82.     gScrapHandle = sourceHandle;
  83.     gCurrentOffset = sourceOffset + sizeof(Picture);
  84.  
  85.     // install our GetPic proc
  86.     if (gMachineInfo.theEnvirons.hasColorQD)
  87.         SetStdCProcs(&gMyColorProcs);
  88.     else
  89.         SetStdProcs(&gMyProcs);
  90.     gMyProcs.getPicProc = gGetPICTData;
  91.     gMyColorProcs.getPicProc = gGetPICTData;
  92.     gSavedProcs = (*qd.thePort).grafProcs;
  93.     if (gMachineInfo.theEnvirons.hasColorQD)
  94.         (*qd.thePort).grafProcs = (QDProcsPtr)&gMyColorProcs;
  95.     else
  96.         (*qd.thePort).grafProcs = &gMyProcs;
  97.     
  98.     // Draw the picture
  99.     DrawPicture(tempPict, &whereToDraw);
  100.     
  101.     // remove our GetPic proc
  102.     (*qd.thePort).grafProcs = gSavedProcs;
  103.  
  104.     DisposeHandle((Handle)tempPict);
  105.     
  106. // FALL THROUGH EXCEPTION HANDLING
  107. FailedNewHandle:
  108.     return anErr;
  109.     
  110. } // DrawPictureFromHandleAndOffset
  111.  
  112. // --------------------------------------------------------------------------------------------------------------
  113. // OOP INTERFACE ROUTINES
  114. // --------------------------------------------------------------------------------------------------------------
  115. static OSErr    ClipboardUpdateWindow(WindowRef pWindow, WindowDataPtr pData)
  116. {
  117. #pragma unused (pData)
  118.  
  119.     OSErr        anErr;
  120.     FontInfo    theInfo;
  121.     long        scrapResult;
  122.     long        offset;
  123.     ResType        validScrapType = '????';
  124.     Rect        topAreaRect;
  125.     RgnHandle    oldClip = NewRgn();
  126.     
  127.     // clear out any data that was there before
  128.     GetClip(oldClip);
  129.     EraseRect(&GetWindowPort(pWindow)->portRect);
  130.     
  131.     // get that scrap!
  132.     anErr = LoadScrap();
  133.     nrequire(anErr, LoadScrap);
  134.     
  135.     // figure out the scrap type and offset
  136.     {
  137.     short i = 0;
  138.     ResType        scrapTypes[] = {'TEXT', 'PICT', '????'};
  139.  
  140.     while (scrapTypes[i] != '????')
  141.         {
  142.         scrapResult = GetScrap(nil, scrapTypes[i], &offset);
  143.         if (scrapResult > 0)
  144.             {
  145.             validScrapType = scrapTypes[i];
  146.             break;
  147.             }
  148.         ++i;
  149.         }
  150.     }
  151.     
  152.     // setup for the drawing
  153.     TextFont(applFont);
  154.     TextSize(9);
  155.     GetFontInfo(&theInfo);
  156.  
  157.     // caclulate our area at the top to say what type of contents the scrap is
  158.     topAreaRect = GetWindowPort(pWindow)->portRect;
  159.     topAreaRect.bottom = topAreaRect.top + theInfo.ascent + theInfo.descent + theInfo.leading * 2 + 2;
  160.  
  161.     // draw two lines under the area to separate it from the rest of the window
  162.     MoveTo(topAreaRect.left, topAreaRect.bottom - 2);
  163.     Line(topAreaRect.right - topAreaRect.left, 0);
  164.     Move(0, 2);
  165.     Line(-(topAreaRect.right - topAreaRect.left), 0);
  166.  
  167.     // draw a string describing the contents
  168.     {
  169.     Str255    theString;
  170.     
  171.     switch (validScrapType)
  172.         {
  173.         case 'PICT':
  174.             GetIndString(theString, kClipboardStrings, iClipboardPICT);
  175.             break;
  176.             
  177.         case 'TEXT':
  178.             GetIndString(theString, kClipboardStrings, iClipboardText);
  179.             break;
  180.             
  181.         default:
  182.             if (InfoScrap()->scrapCount == 0)
  183.                 GetIndString(theString, kClipboardStrings, iClipboardNone);
  184.             else
  185.                 GetIndString(theString, kClipboardStrings, iClipboardUnknown);
  186.             break;
  187.         }
  188.         
  189.     MoveTo(topAreaRect.left + 4, topAreaRect.bottom - 4);
  190.     DrawString(theString);
  191.     }
  192.     
  193.     // calculate the part *not* in our top area    
  194.     topAreaRect.top = topAreaRect.bottom+1;
  195.     topAreaRect.bottom = GetWindowPort(pWindow)->portRect.bottom;
  196.  
  197.     // remember the scrap count -- if it changes, we do an update!
  198.     ((ClipboardDataPtr)pData)->scrapCount = InfoScrap()->scrapCount;
  199.  
  200.     // now, draw the contents, if we have a legal type to use
  201.     {
  202.     Rect    clipArea = topAreaRect;
  203.     Handle    scrapHandle = InfoScrap()->scrapHandle;
  204.     
  205.     clipArea.right -= 15;
  206.     clipArea.bottom -= 15;
  207.     ClipRect(&clipArea);
  208.     switch (validScrapType)
  209.         {
  210.         case 'PICT':
  211.             DrawPictureFromHandleAndOffset(&clipArea, 
  212.                     scrapHandle, offset);
  213.             break;
  214.             
  215.         case 'TEXT':
  216.             {
  217.             char    oldState;
  218.                     
  219.             oldState = HGetState(scrapHandle);
  220.             HLock(scrapHandle);
  221.             clipArea.right -= 15;
  222.             clipArea.bottom -= 15;
  223.             TETextBox(*scrapHandle+offset, scrapResult, &clipArea, teJustLeft);
  224.             }
  225.             break;
  226.         }
  227.     }
  228.     
  229.     // finally draw the grow icon, but omit our top area rect from the drawing
  230.     ClipRect(&topAreaRect);
  231.     DrawGrowIcon(pWindow);
  232.     
  233.     SetClip(oldClip);
  234.     DisposeRgn(oldClip);
  235.     
  236.     UnloadScrap();
  237.     
  238. // FALL THROUGH EXCEPTION HANDLING
  239. LoadScrap:
  240.     return anErr;
  241.     
  242. } // ClipboardUpdateWindow
  243.  
  244.  
  245. // --------------------------------------------------------------------------------------------------------------
  246.  
  247. static Boolean    ClipboardFilterEvent(WindowRef pWindow, WindowDataPtr pData, EventRecord *pEvent)
  248. {    
  249.  
  250.     // Force an update on scrap changes during activate/deactivate.
  251.  
  252.     switch (pEvent->what)
  253.         {
  254.         case nullEvent:
  255.         case activateEvt:
  256.             if (LoadScrap() == noErr)
  257.                 {
  258.                 PScrapStuff pScrap = InfoScrap();
  259.                 
  260.                 if (pScrap->scrapCount != ((ClipboardDataPtr)pData)->scrapCount)
  261.                     {
  262.                     GrafPtr    pPort = (GrafPtr)GetWindowPort(pWindow);
  263.                     
  264.                     SetPort(pPort);
  265.                     InvalRect(&pPort->portRect);
  266.                     }
  267.                 }
  268.             break;
  269.         
  270.         // Follow the HI guidelines and hide the clipboard when we are suspended.
  271.     
  272.         case osEvt:
  273.             if (((pEvent->message >> 24) & 0x0FF) == suspendResumeMessage)
  274.                 {
  275.                 if((pEvent->message & resumeFlag)==0)    // suspending
  276.                     {
  277.                     HideWindow(pWindow);
  278.                     pWindow = FrontWindow();
  279.                     if (pWindow)
  280.                         HiliteWindow(pWindow, false);
  281.                     }
  282.                 else                                    // resuming
  283.                     ShowWindow(pWindow);
  284.                 }
  285.             break;
  286.             
  287.         } // switch(what)
  288.     
  289.     return false;
  290.     
  291. } // ClipboardFilterEvent
  292.  
  293.  
  294. // --------------------------------------------------------------------------------------------------------------
  295.  
  296. static OSErr    ClipboardKeyEvent(WindowRef pWindow, WindowDataPtr pData, EventRecord *pEvent, Boolean isMotionKey)
  297. {    
  298.     #pragma unused(pWindow, pData, pEvent, isMotionKey)
  299.  
  300.     return noErr;
  301.  
  302. } // ClipboardKeyEvent
  303.  
  304.  
  305. // --------------------------------------------------------------------------------------------------------------
  306.  
  307. static OSErr    ClipboardGetBalloon(WindowRef pWindow, WindowDataPtr pData, 
  308.         Point *localMouse, short * returnedBalloonIndex, Rect *returnedRectangle)
  309. {
  310. #pragma unused (pWindow, pData, localMouse, returnedRectangle)
  311.  
  312.     *returnedBalloonIndex = iNoBalloon;
  313.     
  314.     return noErr;
  315.  
  316. } // ClipboardGetBalloon
  317.  
  318. // --------------------------------------------------------------------------------------------------------------
  319.  
  320. static OSErr    ClipboardGetDocumentRect(WindowRef pWindow, WindowDataPtr pData, 
  321.             LongRect * documentRectangle, Boolean forGrow)
  322. {
  323. #pragma unused (pWindow, pData, forGrow)
  324.     
  325.     Rect    maxSize = (**GetGrayRgn()).rgnBBox;
  326.     
  327.     RectToLongRect(&maxSize, documentRectangle);
  328.     
  329.     return noErr;
  330.     
  331. } // ClipboardGetDocumentRect
  332.  
  333.  
  334. // --------------------------------------------------------------------------------------------------------------
  335.  
  336. static OSErr    ClipboardCloseWindow(WindowRef pWindow, void* refCon)
  337. {    
  338. #pragma unused(pWindow,refCon)
  339.  
  340.     ChangeCommandName(cShowClipboard, kClipboardStrings, iClipboardShow);
  341.     UnloadScrap();
  342.     
  343.     return noErr;
  344.  
  345. } // ClipboardCloseWindow
  346.  
  347.  
  348. // --------------------------------------------------------------------------------------------------------------
  349.  
  350. static OSErr    ClipboardMakeWindow(WindowRef pWindow, WindowDataPtr pData)
  351. {
  352. #pragma unused (pWindow)
  353.  
  354.     pData->hasGrow                 = true;
  355.     pData->pFilterEvent         = (FilterEventProc)     ClipboardFilterEvent;
  356.     pData->pKeyEvent            = (KeyEventProc)         ClipboardKeyEvent;
  357.     pData->pGetBalloon            = (GetBalloonProc)         ClipboardGetBalloon;
  358.     pData->pUpdateWindow         = (UpdateWindowProc)     ClipboardUpdateWindow;
  359.     pData->pGetDocumentRect     = (GetDocumentRectProc) ClipboardGetDocumentRect;
  360.     pData->pCloseWindow            = (CloseWindowProc)        ClipboardCloseWindow;
  361.     
  362.     pData->contentRect.right = pData->contentRect.left + 
  363.                     qd.screenBits.bounds.right - qd.screenBits.bounds.left - 96;
  364.     pData->contentRect.bottom = pData->contentRect.top + 150;
  365.     MoveWindow(pWindow, 
  366.             qd.screenBits.bounds.left + 4, 
  367.             qd.screenBits.bounds.bottom - 154, false);
  368.     
  369.     ChangeCommandName(cShowClipboard, kClipboardStrings, iClipboardHide);
  370.  
  371.     return noErr;
  372.     
  373. } // ClipboardMakeWindow
  374.  
  375.  
  376. // --------------------------------------------------------------------------------------------------------------
  377.  
  378. OSErr    ClipboardPreflightWindow(PreflightPtr pPreflightData)
  379. {    
  380.     pPreflightData->resourceID            = kClipboardWindowID;
  381.     pPreflightData->continueWithOpen     = true;
  382.     pPreflightData->makeProcPtr         = ClipboardMakeWindow;
  383.     pPreflightData->storageSize         = sizeof(ClipboardDataRecord);
  384.     
  385.     return noErr;
  386.     
  387. } // ClipboardPreflightWindow
  388.  
  389. // --------------------------------------------------------------------------------------------------------------
  390.  
  391. void ClipboardGetFileTypes(OSType * pFileTypes, OSType * pDocumentTypes, short * numTypes)
  392. {
  393. #pragma unused (pFileTypes, pDocumentTypes, numTypes)
  394.  
  395. } // ClipboardGetFileTypes
  396.